home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / FS.PY < prev    next >
Encoding:
Python Source  |  1999-07-14  |  12.3 KB  |  418 lines
  1. ##############################################################################
  2. # 
  3. # Zope Public License (ZPL) Version 1.0
  4. # -------------------------------------
  5. # 
  6. # Copyright (c) Digital Creations.  All rights reserved.
  7. # 
  8. # This license has been certified as Open Source(tm).
  9. # 
  10. # Redistribution and use in source and binary forms, with or without
  11. # modification, are permitted provided that the following conditions are
  12. # met:
  13. # 
  14. # 1. Redistributions in source code must retain the above copyright
  15. #    notice, this list of conditions, and the following disclaimer.
  16. # 
  17. # 2. Redistributions in binary form must reproduce the above copyright
  18. #    notice, this list of conditions, and the following disclaimer in
  19. #    the documentation and/or other materials provided with the
  20. #    distribution.
  21. # 
  22. # 3. Digital Creations requests that attribution be given to Zope
  23. #    in any manner possible. Zope includes a "Powered by Zope"
  24. #    button that is installed by default. While it is not a license
  25. #    violation to remove this button, it is requested that the
  26. #    attribution remain. A significant investment has been put
  27. #    into Zope, and this effort will continue if the Zope community
  28. #    continues to grow. This is one way to assure that growth.
  29. # 
  30. # 4. All advertising materials and documentation mentioning
  31. #    features derived from or use of this software must display
  32. #    the following acknowledgement:
  33. # 
  34. #      "This product includes software developed by Digital Creations
  35. #      for use in the Z Object Publishing Environment
  36. #      (http://www.zope.org/)."
  37. # 
  38. #    In the event that the product being advertised includes an
  39. #    intact Zope distribution (with copyright and license included)
  40. #    then this clause is waived.
  41. # 
  42. # 5. Names associated with Zope or Digital Creations must not be used to
  43. #    endorse or promote products derived from this software without
  44. #    prior written permission from Digital Creations.
  45. # 
  46. # 6. Modified redistributions of any form whatsoever must retain
  47. #    the following acknowledgment:
  48. # 
  49. #      "This product includes software developed by Digital Creations
  50. #      for use in the Z Object Publishing Environment
  51. #      (http://www.zope.org/)."
  52. # 
  53. #    Intact (re-)distributions of any official Zope release do not
  54. #    require an external acknowledgement.
  55. # 
  56. # 7. Modifications are encouraged but must be packaged separately as
  57. #    patches to official Zope releases.  Distributions that do not
  58. #    clearly separate the patches from the original work must be clearly
  59. #    labeled as unofficial distributions.  Modifications which do not
  60. #    carry the name Zope may be packaged in any form, as long as they
  61. #    conform to all of the clauses above.
  62. # 
  63. # 
  64. # Disclaimer
  65. # 
  66. #   THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
  67. #   EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  68. #   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  69. #   PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
  70. #   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  71. #   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  72. #   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  73. #   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  74. #   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  75. #   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  76. #   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  77. #   SUCH DAMAGE.
  78. # 
  79. # 
  80. # This software consists of contributions made by Digital Creations and
  81. # many individuals on behalf of Digital Creations.  Specific
  82. # attributions are listed in the accompanying credits file.
  83. # 
  84. ##############################################################################
  85.  
  86. import struct, tempfile, string, time, pickle, os, sys
  87. from struct import pack, unpack
  88. from cStringIO import StringIO
  89.  
  90. class FS:
  91.     """FileStorage 'report' writer for converting BoboPOS to FileStorage
  92.     """
  93.  
  94.  
  95.     def __init__(self, fname, file):
  96.         file.seek(0,2)
  97.         self._input_size=file.tell()
  98.         file.seek(0)
  99.         self.__name__=fname
  100.         self._file=open(fname,'w+b')
  101.         self._file.write('FS21')
  102.  
  103.         self._index={}
  104.         self._indexpos=self._index.get
  105.         self._tindex=[]
  106.         self._tappend=self._tindex.append
  107.         self._tfile=tempfile.TemporaryFile()
  108.         self._pos=4
  109.         self._progress=None
  110.         
  111.  
  112.     def rpt(self, pos, oid, start, tname, user, t, p, first, newtrans):
  113.         if pos is None:
  114.             self.tpc_finish()
  115.             sys.stderr.write(' %% 100     \n')
  116.             return
  117.         else:
  118.             progress=' %% %.1f \r' % (pos*100.0/self._input_size)
  119.             if progress != self._progress:
  120.                 sys.stderr.write(progress)
  121.                 self._progress=progress
  122.  
  123.         if newtrans:
  124.             try: string.atof(tname)
  125.             except:
  126.                 # Ugh, we have a weird tname.  We'll just ignore the transaction
  127.                 # boundary and merge transactions
  128.                 if first:
  129.                     # But we can't ignore the first one, so we'll hack in a
  130.                     # bogus start date
  131.                     self.tpc_begin('100', user, t)
  132.             else:
  133.                 if not first: self.tpc_finish()
  134.                 self.tpc_begin(tname, user, t)
  135.         self.store(oid, p)
  136.  
  137.     def store(self, oid, data):
  138.         old=self._indexpos(oid, 0)
  139.         pnv=None
  140.  
  141.         tfile=self._tfile
  142.         write=tfile.write
  143.         pos=self._pos
  144.         here=tfile.tell()+pos+self._thl
  145.         self._tappend(oid, here)
  146.         serial=self._serial
  147.         data=fixpickle(data, oid)
  148.         write(pack(">8s8s8s8sH8s",
  149.                    p64(oid+1),serial,p64(old),p64(pos),
  150.                    0,p64(len(data))
  151.                    )
  152.               )
  153.  
  154.         write(data)
  155.  
  156.     def tpc_begin(self, tname, user, desc):
  157.         del self._tindex[:]   # Just to be sure!
  158.         self._tfile.seek(0)
  159.  
  160.         t=string.atof(tname)
  161.         y,m,d,h,mi=time.gmtime(t)[:5]
  162.         s=t%60
  163.         self._serial=struct.pack(
  164.             ">II",
  165.             (((((y-1900)*12)+m-1)*31+d-1)*24+h)*60+mi,
  166.             long(s * (1L << 32) / 60)
  167.             )
  168.  
  169.         # Ugh, we have to record the transaction header length
  170.         # so that we can get version pointers right.
  171.         self._thl=23+len(user)+len(desc)
  172.  
  173.         # And we have to save the data used to compute the
  174.         # header length. It's unlikely that this stuff would
  175.         # change, but if it did, it would be a disaster.
  176.         self._ud=user, desc
  177.  
  178.     def tpc_finish(self):
  179.         file=self._file
  180.         write=file.write
  181.         tfile=self._tfile
  182.         dlen=tfile.tell()
  183.         tfile.seek(0)
  184.         id=self._serial
  185.         user, desc = self._ud
  186.         self._ud=None
  187.                         
  188.         tlen=self._thl
  189.         pos=self._pos
  190.         tl=tlen+dlen
  191.         stl=p64(tl)
  192.         write(pack(
  193.             ">8s" "8s" "c"  "H"        "H"        "H"
  194.             ,id, stl, ' ', len(user), len(desc), 0,
  195.             ))
  196.         if user: write(user)
  197.         if desc: write(desc)
  198.             
  199.         cp(tfile, file, dlen)
  200.                 
  201.         write(stl)
  202.         self._pos=pos+tl+8
  203.  
  204.         tindex=self._tindex
  205.         index=self._index
  206.         for oid, pos in tindex: index[oid]=pos
  207.         del tindex[:]
  208.  
  209.  
  210. class ZEXP:
  211.     """Zope Export format 'report' writer
  212.     """
  213.     def __init__(self, fname, file):
  214.         file.seek(0,2)
  215.         self._input_size=file.tell()
  216.         file.seek(0)
  217.         self.__name__=fname
  218.         self._file=open(fname,'w+b')
  219.         self._file.write('ZEXP')
  220.  
  221.         self._pos=4
  222.         self._progress=None
  223.         
  224.  
  225.     def rpt(self, pos, oid, start, tname, user, t, p, first, newtrans):
  226.         write=self._file.write
  227.         if pos is None:
  228.             write('\377'*16) # end marker
  229.             sys.stderr.write(' %% 100     \n')
  230.             return
  231.         else:
  232.             progress=' %% %.1f \r' % (pos*100.0/self._input_size)
  233.             if progress != self._progress:
  234.                 sys.stderr.write(progress)
  235.                 self._progress=progress
  236.  
  237.         data=fixpickle(p, oid)
  238.         l=len(data)
  239.         write(p64(oid+1)+p64(l))
  240.         write(data)
  241.         self._pos=self._pos+l+16
  242.  
  243.  
  244. t32 = 1L << 32
  245.  
  246. def p64(v, pack=struct.pack):
  247.     if v < t32: h=0
  248.     else:
  249.         h=v/t32
  250.         v=v%t32
  251.     return pack(">II", h, v)
  252.  
  253. def cp(f1, f2, l):
  254.     read=f1.read
  255.     write=f2.write
  256.     n=8192
  257.     
  258.     while l > 0:
  259.         if n > l: n=l
  260.         d=read(n)
  261.         write(d)
  262.         l = l - len(d)
  263.  
  264.     
  265. class Ghost: pass
  266.  
  267. class Global:
  268.     __safe_for_unpickling__=1
  269.     
  270.     def __init__(self, m, n):
  271.         self._module, self._name = m, n
  272.  
  273.     def __call__(self, *args):
  274.         return Inst(self, args)
  275.  
  276.     def __basicnew__(self):
  277.         return Inst(self, None)
  278.  
  279. def _global(m, n):
  280.     if m[:8]=='BoboPOS.':
  281.         if m=='BoboPOS.PickleDictionary' and n=='Root':
  282.             m='ZODB.conversionhack'
  283.             n='hack'
  284.         elif m=='BoboPOS.PersistentMapping': m='Persistence'
  285.         elif m=='BoboPOS.cPickleJar' and n=='ec':
  286.             m=n='ExtensionClass'
  287.         else:
  288.             raise 'Unexpected BoboPOS class', (m, n)
  289.     elif m=='PersistentMapping': m='Persistence'
  290.  
  291.     return Global(m,n)
  292.     
  293.  
  294. class Inst:
  295.  
  296.     _state=None
  297.     
  298.     def __init__(self, c, args):
  299.         self._cls=c
  300.         self._args=args
  301.  
  302.     def __setstate__(self, state): self._state=state
  303.  
  304.  
  305. from pickle import INST, GLOBAL, MARK, BUILD, OBJ, REDUCE
  306.  
  307. InstanceType=type(Ghost())
  308.  
  309. class Unpickler(pickle.Unpickler):
  310.  
  311.     dispatch={}
  312.     dispatch.update(pickle.Unpickler.dispatch)
  313.  
  314.     def load_inst(self):
  315.         k = self.marker()
  316.         args = tuple(self.stack[k+1:])
  317.         del self.stack[k:]
  318.         module = self.readline()[:-1]
  319.         name = self.readline()[:-1]
  320.         klass = _global(module, name)
  321.         value=Inst(klass, args)
  322.         self.append(value)
  323.             
  324.     dispatch[INST] = load_inst
  325.  
  326.     def load_global(self):
  327.         module = self.readline()[:-1]
  328.         name = self.readline()[:-1]
  329.         klass = _global(module, name)
  330.         self.append(klass)
  331.     dispatch[GLOBAL] = load_global
  332.  
  333.     def persistent_load(self, oid,
  334.                         TupleType=type(()), Ghost=Ghost, p64=p64):
  335.         "Remap object ids from ZODB 2 stype to ZODB 3 style"
  336.  
  337.         if type(oid) is TupleType:
  338.             oid, klass = oid
  339.             oid = p64(oid+1), klass
  340.         else:
  341.             oid = p64(oid+1)
  342.             
  343.         Ghost=Ghost()
  344.         Ghost.oid=oid
  345.         return Ghost
  346.  
  347.  
  348. class Pickler(pickle.Pickler):
  349.  
  350.     dispatch={}
  351.     dispatch.update(pickle.Pickler.dispatch)
  352.  
  353.     def persistent_id(self, object, Ghost=Ghost):
  354.         if hasattr(object, '__class__') and object.__class__ is Ghost:
  355.             return object.oid
  356.  
  357.     def save_inst(self, object):
  358.         d = id(object)
  359.         cls = object.__class__
  360.  
  361.         memo  = self.memo
  362.         write = self.write
  363.         save  = self.save
  364.  
  365.         if cls is Global:
  366.             memo_len = len(memo)
  367.             write(GLOBAL + object._module + '\n' + object._name + '\n' +
  368.                   self.put(memo_len))
  369.             memo[d] = (memo_len, object)
  370.             return
  371.  
  372.         self.save_inst(object._cls)
  373.         save(object._args)
  374.  
  375.         memo_len = len(memo)
  376.         write(REDUCE + self.put(memo_len))
  377.  
  378.         memo[d] = (memo_len, object)
  379.  
  380.         stuff=object._state
  381.         save(stuff)
  382.         write(BUILD)
  383.  
  384.     dispatch[InstanceType] = save_inst
  385.  
  386.     def save_global(self, object, name = None):
  387.         write = self.write
  388.         memo = self.memo
  389.  
  390.         if (name is None):
  391.             name = object._name
  392.  
  393.         module=object._module
  394.  
  395.         memo_len = len(memo)
  396.         write(GLOBAL + module + '\n' + name + '\n' +
  397.             self.put(memo_len))
  398.         memo[id(object)] = (memo_len, object)
  399.  
  400.     dispatch[type(Ghost)] = save_global
  401.     
  402.     
  403. def fixpickle(p, oid):
  404.     
  405.     pfile=StringIO(p)
  406.     unpickler=Unpickler(pfile)
  407.  
  408.     newp=StringIO()
  409.     pickler=Pickler(newp,1)
  410.  
  411.     pickler.dump(unpickler.load())
  412.     state=unpickler.load()
  413.     if oid==-1: state={'_container': state}
  414.     pickler.dump(state)
  415.     p=newp.getvalue()
  416.  
  417.     return p
  418.